home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / a86v302b.arc / 06INSTR.DOC next >
Text File  |  1987-04-08  |  42KB  |  715 lines
  1. CHAPTER 6    THE 86 INSTRUCTION SET                       6-1
  2.  
  3. Since this is the start of the A86VxxxB.ARC file, I'll repeat 
  4. here that the entire A86 package is Copyright (C)1986--1987 Eric 
  5. Isaacson.  All rights reserved.  If this is all you've got, you 
  6. need to get A86VxxxA.ARC, which contains the program and the 
  7. first half of the manual.
  8.  
  9.  
  10. Effective Addresses
  11.  
  12. Most memory data accessing in the 86 family is accomplished via 
  13. the mechanism of the effective address.  Wherever an effective 
  14. address specifier "eb", "ew" or "ed" appears in the list of 8086 
  15. instructions, you may use a wide variety of actual operands in 
  16. that instruction.  These include general registers, memory 
  17. variables, and a variety of indexed memory quantities.  
  18.  
  19. GENERAL REGISTERS: Wherever an "ew" appears, you can use any of 
  20.    the 16-bit registers AX,BX,CX,DX,SI,DI,SP, or BP.  Wherever an 
  21.    "eb" appears, you can use any of the 8-bit registers 
  22.    AL,BL,CL,DL,AH,BH,CH, or DH.  For example, the "ADD ew,rw" 
  23.    form subsumes the 16-bit register-to-register adds; for 
  24.    example, ADD AX,BX; ADD SI,BP; ADD SP,AX.  
  25.  
  26. MEMORY VARIABLES: Wherever an "ew" appears, you can use a word-
  27.    memory-variable.  Wherever an "eb" appears, you can use a 
  28.    byte-memory-variable.  Variables are typically declared in the 
  29.    DATA segment, using a DW declaration for a word-variable, or a 
  30.    DB declaration for a byte-variable.  For example, you can 
  31.    declare variables: 
  32.  
  33.      DATA_PTR  DW ?
  34.      ESC_CHAR  DB ?
  35.  
  36.    Later, you can load or store these variables:
  37.  
  38.      MOV SI,DATA_PTR    ; load DATA_PTR into SI for use
  39.      LODSW              ; fetch the word pointed to by DATA_PTR
  40.      MOV DATA_PTR,SI    ; store the value incremented by the LODSW
  41.      MOV BL,ESC_CHAR    ; load the byte-variable ESC_CHAR
  42.  
  43.    Alternatively, you can address specific unnamed memory 
  44.    locations by enclosing the location value in square brackets; 
  45.    for example, 
  46.  
  47.      MOV AL,[02000]     ; load contents of location 02000 into AL
  48.  
  49.    Note that A86 discerned from context (loading into AL) that a 
  50.    BYTE at 02000 was intended.  Sometimes this is impossible, and 
  51.    you must specify byte or word: 
  52.  
  53.      INC B[02000]       ; increment the byte at location 02000
  54.      MOV W[02000],0     ; set the WORD at location 02000 to zero
  55.                                                           6-2
  56. INDEXED MEMORY: The 86 supports the use of certain registers as 
  57.    base pointers and index registers into memory.  BX and BP are 
  58.    the base registers; SI and DI are the index registers.  You 
  59.    may combine at most one base register, at most one index 
  60.    register, and a constant number into a run-time pointer that 
  61.    determines the location of the effective address memory to be 
  62.    used in the instruction.  These can be given explicitly, by 
  63.    enclosing the index registers in brackets: 
  64.  
  65.         MOV AX,[BX]
  66.         MOV CX,W[SI+17]
  67.         MOV AX,[BX+BP+5]
  68.         MOV AX,[BX][BP]5 ; another way to write the same instr.
  69.  
  70.    Or, indexing can be accomplished by declaring variables in a 
  71.    based structure: 
  72.  
  73.         STRUC [BP]         ; NOTE based structures are unique to A86!
  74.           BP_SAVE   DW ?
  75.           RET_ADDR  DW ?
  76.           PARM1     DW ?
  77.           PARM2     DW ?
  78.         ENDS
  79.         INC PARM1         ; equivalent to INC W[BP+4]
  80.  
  81.     Finally, indexing can be done by mixing explicit components 
  82.     with declared ones: 
  83.  
  84.         TABLE    DB  4,2,1,3,5
  85.         MOV AL,TABLE[BX]
  86.  
  87.  
  88. Segmentation and Effective Addresses
  89.  
  90. The 86 family has four segment registers, CS, DS, ES, and SS, 
  91. used to address memory.  Each segment register points to 64K 
  92. bytes of memory within the 1-megabyte memory space of the 86.  
  93. (The start of the 64K is calculated by multiplying the segment 
  94. register value by 16; i.e., by shifting the value left by one hex 
  95. digit.)  If your program's code, data and stack areas can all fit 
  96. in the same 64K bytes, you can leave all the segment registers 
  97. set to the same value.  In that case, you won't have to think 
  98. about segment registers--no matter which one is used to address 
  99. memory, you'll still get the same 64K.  If your program needs 
  100. more than 64K, you must point one or more segment registers to 
  101. other parts of the memory space.  In this case, you must take 
  102. care that your memory references use the segment registers you 
  103. intended.  
  104.  
  105. Each effective address memory access has a default segment 
  106. register, to be used if you do not explicitly specify which 
  107. segment register you wish.  For most effective addresses, the 
  108. default segment register is DS.  The exceptions are those 
  109. effective addresses that use the BP register for indexing.  All 
  110. BP-indexed memory references have a default of SS.  (This is 
  111. because BP is intended to be used for addressing local variables, 
  112. stored on the stack.) 
  113.                                                           6-3
  114. If you wish your memory access to use a different segment 
  115. register, you provide a segment-override byte before the 
  116. instruction containing the effective address operand.  In the A86 
  117. language, you code the override by giving the name of the segment 
  118. register you wish before the instruction mnemonic.  For example, 
  119. suppose you want to load the AL register with the memory byte 
  120. pointed to by BX.  If you code MOV AL,[BX], the DS register will 
  121. be used to determine which 64K segment BX is pointing to.  If you 
  122. want the byte to come from the CS-segment instead, you code CS 
  123. MOV AL,[BX].  Be aware that the segment-override byte has effect 
  124. only upon the single instruction that follows it.  If you have a 
  125. sequence of instructions requiring overrides, you must give an 
  126. override byte before every instruction in the sequence.  (In that 
  127. case, you may wish to consider changing the value of the default 
  128. segment register for the duration of the sequence.) 
  129.  
  130. NOTE: This method for providing segment-overrides is unique to 
  131. the A86 assembler!  The assemblers provided by Intel and IBM (MS-
  132. DOS) attempt to figure out segment allocation for you, and plug 
  133. in segment-override bytes "behind your back".  In order to do 
  134. this, those assemblers require you to inform them which variables 
  135. and structures are pointed to by which segment registers.  That 
  136. is what the ASSUME directive in those assemblers is all about.  I 
  137. wrote Intel's first 86 assembler, ASM86, so I have been watching 
  138. the situation since day one.  Over the years, I have concluded 
  139. that the ASSUME-mechanism creates far, far more confusion that it 
  140. solves.  So I scrapped it; and the result is an assembler with 
  141. far less red tape.  But if your program needs more than 64K, you 
  142. do have to manage those segment registers yourself; so take care!  
  143.  
  144.  
  145. Effective Use of Effective Addresses
  146.  
  147. Remember that all of the common instructions of the 86 family 
  148. allow effective addresses as operands.  (The only major functions 
  149. that don't are the AL/AX specific ones: multiply, divide, and 
  150. input/output).  This means that you don't have to funnel many 
  151. through AL or AX just to do something with them.  You can perform 
  152. all the common arithmetic, PUSH/POP, and MOVes from any general 
  153. register to any general register; from any memory location 
  154. (indexed if you like) to any register; and (this is most often 
  155. overlooked) from any register TO memory.  The only thing you 
  156. can't do in general is memory-to-memory.  Among the more common 
  157. operations that inexperienced 86 programmers overlook are: 
  158.  
  159.    * setting memory variables to immediate values
  160.    * testing memory variables, and comparing them to constants
  161.    * preserving memory variables by PUSHing and POPping them
  162.    * incrementing and decrementing memory variables
  163.    * adding into memory variables
  164.                                                           6-4
  165. Encoding of Effective Addresses
  166.  
  167. Unless you are concerned with the nitty-gritty details of 86 
  168. instruction encoding, you don't need to read this section.  
  169.  
  170. Every instruction with an effective address has an encoded byte, 
  171. known as the effective address byte, following the 1-byte opcode 
  172. for the instruction. (For obscure reasons, Intel calls this byte 
  173. the ModRM byte.)  If the effective address is a memory variable, 
  174. or an indexed memory location with a non-zero constant offset, 
  175. then the effective address byte will be immediately followed by 
  176. the offset amount.  Amounts in the range -128 to +127 are given 
  177. by a single signed byte, denoted by "d8" in the table below.  
  178. Amounts requiring a 2-byte representation are denoted by "d16" in 
  179. the table below.  As with all 16-bit memory quantities in the 86 
  180. family, the word is stored with the least significant byte FIRST.  
  181.  
  182. The following table of effective address byte values is organized 
  183. into 32 rows and 8 columns.  The 32 rows give the possible values 
  184. for the effective address operand: 8 registers and 24 memory 
  185. indexing modes.  A 25th indexing mode, [BP] with zero 
  186. displacement, has been pre-empted by the simple-memory-variable 
  187. case.  If you code [BP] with no displacement, you will get 
  188. [BP]+d8, with a d8-value of zero.  
  189.  
  190. The 8 columns of the table reflect further information given by 
  191. the effective address byte.  Usually, this is the identity of the 
  192. other (always a register) operand of a 2-operand instruction.  
  193. Those instructions are identified by a "/r" following the opcode 
  194. byte in the instruction list.  Sometimes, the information given 
  195. supplements the opcode byte in identifying the instruction 
  196. itself.  Those instructions are identified by a "/" followed by a 
  197. digit from 0 through 7.  The digit tells which of the 8 columns 
  198. you should use to find the effective address byte.  
  199.  
  200. For example, suppose you have a perverse wish to know the precise 
  201. bytes encoded by the instruction SUB B[BX+17],100.  This 
  202. instruction subtracts an immediate quantity, 100, from an 
  203. effective address quantity, B[BX+17].  By consulting the 
  204. instruction list, you find the general form SUB eb,ib.  The 
  205. opcode bytes given there are 80 /5 ib.  The "/5" denotes an 
  206. effective-address byte, whose value will be taken from column 5 
  207. of the table below.  The offset 17 decimal, which is 11 hex, will 
  208. fit in a single "d8" byte, so we take our value from the "[BX] + 
  209. d8" row.  The table tells us that the effective address byte is 
  210. 6F.  Immediately following the 6F is the offset, 11 hex.  
  211. Following that is the ib-value of 100 decimal, which is 64 hex.  
  212. So the bytes generated by SUB B[BX+17],100 are 80 6F 11 64.  
  213.                                                           6-5
  214.  
  215. Table of Effective Address byte values
  216.  
  217. s  =    ES   CS   SS   DS
  218. rb =    AL   CL   DL   BL   AH   CH   DH   BH
  219. rw =    AX   CX   DX   BX   SP   BP   SI   DI
  220. digit=   0    1    2    3    4    5    6    7
  221.                                                Effective
  222. EA byte                                         address:
  223. values: 00   08   10   18   20   28   30   38    [BX + SI]
  224.         01   09   11   19   21   29   31   39    [BX + DI]
  225.         02   0A   12   1A   22   2A   32   3A    [BP + SI]
  226.         03   0B   13   1B   23   2B   33   3B    [BP + DI]
  227.         04   0C   14   1C   24   2C   34   3C    [SI]
  228.         05   0D   15   1D   25   2D   35   3D    [DI]
  229.         06   0E   16   1E   26   2E   36   3E    d16 (simple var)
  230.         07   0F   17   1F   27   2F   37   3F    [BX]
  231.         40   48   50   58   60   68   70   78    [BX + SI] + d8
  232.         41   49   51   59   61   69   71   79    [BX + DI] + d8
  233.         42   4A   52   5A   62   6A   72   7A    [BP + SI] + d8
  234.         43   4B   53   5B   63   6B   73   7B    [BP + DI] + d8
  235.         44   4C   54   5C   64   6C   74   7C    [SI] + d8
  236.         45   4D   55   5D   65   6D   75   7D    [DI] + d8
  237.         46   4E   56   5E   66   6E   76   7E    [BP] + d8
  238.         47   4F   57   5F   67   6F   77   7F    [BX] + d8
  239.         80   88   90   98   A0   A8   B0   B8    [BX + SI] + d16
  240.         81   89   91   99   A1   A9   B1   B9    [BX + DI] + d16
  241.         82   8A   92   9A   A2   AA   B2   BA    [BP + SI] + d16
  242.         83   8B   93   9B   A3   AB   B3   BB    [BP + DI] + d16
  243.         84   8C   94   9C   A4   AC   B4   BC    [SI] + d16
  244.         85   8D   95   9D   A5   AD   B5   BD    [DI] + d16
  245.         86   8E   96   9E   A6   AE   B6   BE    [BP] + d16
  246.         87   8F   97   9F   A7   AF   B7   BF    [BX] + d16
  247.         C0   C8   D0   D8   E0   E8   F0   F8    ew=AX   eb=AL
  248.         C1   C9   D1   D9   E1   E9   F1   F9    ew=CX   eb=CL
  249.         C2   CA   D2   DA   E2   EA   F2   FA    ew=DX   eb=DL
  250.         C3   CB   D3   DB   E3   EB   F3   FB    ew=BX   eb=BL
  251.         C4   CC   D4   DC   E4   EC   F4   FC    ew=SP   eb=AH
  252.         C5   CD   D5   DD   E5   ED   F5   FD    ew=BP   eb=CH
  253.         C6   CE   D6   DE   E6   EE   F6   FE    ew=SI   eb=DH
  254.         C7   CF   D7   DF   E7   EF   F7   FF    ew=DI   eb=BH
  255.  
  256. d8 denotes an 8-bit displacement following the EA byte,
  257. to be sign-extended and added to the index.
  258.  
  259. d16 denotes a 16-bit displacement following the EA byte,
  260. to be added to the index.
  261.  
  262. Default segment register is SS for effective addresses containing
  263. a BP index; DS for other memory effective addresses.
  264.                                                           6-6
  265. How to Read the Instruction Set Chart
  266.  
  267. The chart below summarizes the machine instructions you can 
  268. program with A86.  In order to use the chart, you need to learn 
  269. the meanings of the specifiers (each given by 2 lower-case 
  270. letters), that follow most of the instruction mnemonics.  Each 
  271. specifier indicates the type of operand (register byte, immediate 
  272. word, etc.) that follows the mnemonic to produce the given 
  273. opcodes.  
  274.  
  275. "c" means the operand is a code label, pointing to a part of the 
  276.     program to be jumped to or called.  A86 will also accept a 
  277.     constant offset in this place (or a constant segment-offset 
  278.     pair in the case of "cd").  "cb" is a label within about 128 
  279.     bytes (in either direction) of the current location.  "cw" is 
  280.     a label within the same code segment as this program; "cd" is 
  281.     a pair of constants separated by a colon-- the segment value 
  282.     to the left of the colon, and the offset to the right.  Note 
  283.     that in both the cb and cw cases, the object code generated 
  284.     is the offset from the location following the current 
  285.     instruction, not the absolute location of the label operand.  
  286.     In some assemblers (most notably for the Z-80 processor) you 
  287.     have to code this offset explicitly by putting "$-" before 
  288.     every relative jump operand in your source code.  You do NOT 
  289.     need to, and should not do so with A86.  
  290.  
  291. "e" means the operand is an Effective Address.  The concept of an 
  292.     Effective Address is central to the 86 machine architecture, 
  293.     and thus to 86 assembly language programming.  It is 
  294.     described in detail at the start of Chapter 8.  We summarize 
  295.     here by saying that an Effective Address is either a general-
  296.     purpose register, a memory variable, or an indexed memory 
  297.     quantity.  For example, the instruction "ADD rb,eb" includes 
  298.     the instructions: ADD AL,BL, or ADD CH,BYTEVAR, or ADD 
  299.     DL,B[BX+17].  
  300.  
  301. "i" means the operand is an immediate constant, provided as part 
  302.     of the instruction itself.  "ib" is a byte-sized constant; 
  303.     "iw" is a constant occupying a full 16-bit word.  The operand 
  304.     can also be a label, defined with a colon.  In that case, the 
  305.     immediate constant which is the location of the label is 
  306.     used.  Examples:  "MOV rw,iw" includes the instructions: MOV 
  307.     AX,17, or MOV SI,VAR_ARRAY, where "VAR_ARRAY:" appears 
  308.     somewhere in the program, defined with a colon.  NOTE that if 
  309.     VAR_ARRAY were defined without a colon, e.g., "VAR_ARRAY DW 
  310.     1,2,3", then "MOV SI,VAR_ARRAY" would be a "MOV rw,ew" NOT a 
  311.     "MOV rw,iw".  The MOV would move the contents of memory at 
  312.     VAR_ARRAY (in this case 1) into SI, instead of the location 
  313.     of the memory. To load the location, you can code "MOV 
  314.     SI,OFFSET VAR_ARRAY".  
  315.  
  316. "m" means a memory variable or an indexed memory quantity; i.e., 
  317.     any Effective Address EXCEPT a register.  
  318.  
  319. "r" means the operand is a general-purpose register.  The 8 "rb" 
  320.     registers are AL,BL,CL,DL,AH,BH,CH,DH; the 8 "rw" registers 
  321.     are AX,BX,CX,DX,SI, DI,BP,SP.  
  322.                                                           6-7
  323.  
  324. WARNING: Instruction forms marked with "*" by the mnemonic are 
  325.     part of the extended 186/286/NEC instruction set.  
  326.     Instructions marked with "#" are unique to the NEC 
  327.     processors.  These instructions will NOT work on the 8088 of 
  328.     the IBM-PC; nor will they work on the 8086; nor will the NEC 
  329.     instructions work on the 186 or 286. If you wish your 
  330.     programs to run on all PC's, do not use these instructions!  
  331.  
  332. Opcodes    Instruction    Description
  333. -------    -----------    -----------
  334. 37          AAA           ASCII adjust AL (carry into AH) after addition
  335. D5 0A       AAD           ASCII adjust before division (AX = 10*AH + AL)
  336. D4 0A       AAM           ASCII adjust after multiply (AL/10: AH=Quo AL=Rem)
  337. 3F          AAS           ASCII adjust AL (borrow from AH) after subtraction
  338. 14 ib       ADC AL,ib     Add with carry immediate byte into AL
  339. 15 iw       ADC AX,iw     Add with carry immediate word into AX
  340. 80 /2 ib    ADC eb,ib     Add with carry immediate byte into EA byte
  341. 10 /r       ADC eb,rb     Add with carry byte register into EA byte
  342. 83 /2 ib    ADC ew,ib     Add with carry immediate byte into EA word
  343. 81 /2 iw    ADC ew,iw     Add with carry immediate word into EA word
  344. 11 /r       ADC ew,rw     Add with carry word register into EA word
  345. 12 /r       ADC rb,eb     Add with carry EA byte into byte register
  346. 13 /r       ADC rw,ew     Add with carry EA word into word register
  347. 04 ib       ADD AL,ib     Add immediate byte into AL
  348. 05 iw       ADD AX,iw     Add immediate word into AX
  349. 80 /0 ib    ADD eb,ib     Add immediate byte into EA byte
  350. 00 /r       ADD eb,rb     Add byte register into EA byte
  351. 83 /0 ib    ADD ew,ib     Add immediate byte into EA word
  352. 81 /0 iw    ADD ew,iw     Add immediate word into EA word
  353. 01 /r       ADD ew,rw     Add word register into EA word
  354. 02 /r       ADD rb,eb     Add EA byte into byte register
  355. 03 /r       ADD rw,ew     Add EA word into word register
  356. 0F 20      #ADD4S         Add CL nibbles BCD from DS:SI into ES:DI (CL even,NZ)
  357. 24 ib       AND AL,ib     Logical-AND immediate byte into AL
  358. 25 iw       AND AX,iw     Logical-AND immediate word into AX
  359. 80 /4 ib    AND eb,ib     Logical-AND immediate byte into EA byte
  360. 20 /r       AND eb,rb     Logical-AND byte register into EA byte
  361. 81 /4 iw    AND ew,iw     Logical-AND immediate word into EA word
  362. 21 /r       AND ew,rw     Logical-AND word register into EA word
  363. 22 /r       AND rb,eb     Logical-AND EA byte into byte register
  364. 23 /r       AND rw,ew     Logical-AND EA word into word register
  365. 63 /r      *ARPL ew,rw    Adjust RPL of EA word not smaller than RPL of rw
  366. 62 /r      *BOUND rw,md   INT 5 if rw not between [md] and [md+2] inclusive
  367. 9A cd       CALL cd       Call far segment, immediate 4-byte address
  368. E8 cw       CALL cw       Call near, offset relative to next instruction
  369. FF /3       CALL ed       Call far segment, address at EA doubleword
  370. FF /2       CALL ew       Call near, offset absolute at EA word
  371. 0F FF ib   #CALL80 ib     Call 8080-emulation code at INT number ib
  372. 98          CBW           Convert byte into word (AH = top bit of AL)
  373. F8          CLC           Clear carry flag
  374. FC          CLD           Clear direction flag so SI and DI will increment
  375. FA          CLI           Clear interrupt enable flag; interrupts disabled
  376. 0F 12/0    #CLRBIT eb,CL  Clear bit CL of eb
  377. 0F 13/0    #CLRBIT ew,CL  Clear bit CL of ew
  378. 0F 1A/0 ib #CLRBIT eb,ib  Clear bit ib of eb
  379. 0F 1B/0 ib #CLRBIT ew,ib  Clear bit ib of ew
  380.                                                           6-8
  381.  
  382. 0F 06      *CLTS          Clear task switched flag
  383. F5          CMC           Complement carry flag
  384. 3C ib       CMP AL,ib     Subtract immediate byte from AL for flags only
  385. 3D iw       CMP AX,iw     Subtract immediate word from AX for flags only
  386. 80 /7 ib    CMP eb,ib     Subtract immediate byte from EA byte for flags only
  387. 38 /r       CMP eb,rb     Subtract byte register from EA byte for flags only
  388. 83 /7 ib    CMP ew,ib     Subtract immediate byte from EA word for flags only
  389. 81 /7 iw    CMP ew,iw     Subtract immediate word from EA word for flags only
  390. 39 /r       CMP ew,rw     Subtract word register from EA word for flags only
  391. 3A /r       CMP rb,eb     Subtract EA byte from byte register for flags only
  392. 3B /r       CMP rw,ew     Subtract EA word from word register for flags only
  393. 0F 26      #CMP4S         Compare CL nibbles CD at DS:SI from ES:DI (CL even,NZ)
  394. A6          CMPS mb,mb    Compare bytes ES:[DI] from [SI], advance SI and DI
  395. A7          CMPS mw,mw    Compare words ES:[DI] from [SI], advance SI and DI
  396. A6          CMPSB         Compare bytes ES:[DI] from DS:[SI], advance SI and DI
  397. A7          CMPSW         Compare words ES:[DI] from DS:[SI], advance SI and DI
  398. 99          CWD           Convert word to doubleword (DX = top bit of AX)
  399. 27          DAA           Decimal adjust AL after addition
  400. 2F          DAS           Decimal adjust AL after subtraction
  401. FE /1       DEC eb        Decrement EA byte by 1
  402. FF /1       DEC ew        Decrement EA word by 1
  403. 48+rw       DEC rw        Decrement word register by 1
  404. F6 /6       DIV eb        Unsigned divide AX by EA byte (AL=Quo AH=Rem)
  405. F7 /6       DIV ew        Unsigned divide DXAX by EA word (AX=Quo DX=Rem)
  406. C8 iw 00   *ENTER iw,0    Make stack frame, iw bytes local storage, 0 levels
  407. C8 iw 01   *ENTER iw,1    Make stack frame, iw bytes local storage, 1 level
  408. C8 iw ib   *ENTER iw,ib   Make stack frame, iw bytes local storage, ib levels
  409.             Fany          Floating point set is in Chapter 7
  410. F4          HLT           Halt
  411. F6 /7       IDIV eb       Signed divide AX by EA byte (AL=Quo AH=Rem)
  412. F7 /7       IDIV ew       Signed divide DXAX by EA word (AX=Quo DX=Rem)
  413. F6 /5       IMUL eb       Signed multiply (AX = AL * EA byte)
  414. F7 /5       IMUL ew       Signed multiply (DXAX = AX * EA word)
  415. 6B /r ib   *IMUL rw,ib    Signed multiply immediate byte into word register
  416. 69 /r iw   *IMUL rw,iw    Signed multiply immediate word into word register
  417. 69 /r iw   *IMUL rw,ew,iw Signed multiply (rw = EA word * immediate word)
  418. 6B /r ib   *IMUL rw,ew,ib Signed multiply (rw = EA word * immediate byte)
  419. E4 ib       IN AL,ib      Input byte from immediate port into AL
  420. EC          IN AL,DX      Input byte from port DX into AL
  421. E5 ib       IN AX,ib      Input word from immediate port into AX
  422. ED          IN AX,DX      Input word from port DX into AX
  423. FE /0       INC eb        Increment EA byte by 1
  424. FF /0       INC ew        Increment EA word by 1
  425. 40+rw       INC rw        Increment word register by 1
  426. 6C         *INS eb,DX     Input byte from port DX into [DI]
  427. 6D         *INS ew,DX     Input word from port DX into [DI]
  428. 6C         *INSB          Input byte from port DX into ES:[DI]
  429. 6D         *INSW          Input word from port DX into ES:[DI]
  430. CC          INT 3         Interrupt 3 (trap to debugger) (far call, with flags
  431. CD ib       INT ib        Interrupt numbered by immediate byte     pushed first)
  432. CE          INTO          Interrupt 4 if overflow flag is 1
  433. CF          IRET          Interrupt return (far return and pop flags)
  434.                                                           6-9
  435.  
  436. 77 cb       JA cb         Jump short if above (CF=0 and ZF=0)    above=UNSIGNED
  437. 73 cb       JAE cb        Jump short if above or equal (CF=0)
  438. 72 cb       JB cb         Jump short if below (CF=1)             below=UNSIGNED
  439. 76 cb       JBE cb        Jump short if below or equal (CF=1 or ZF=1)
  440. 72 cb       JC cb         Jump short if carry (CF=1)
  441. E3 cb       JCXZ cb       Jump short if CX register is zero
  442. 74 cb       JE cb         Jump short if equal (ZF=1)
  443. 7F cb       JG cb         Jump short if greater (ZF=0 and SF=OF)  greater=SIGNED
  444. 7D cb       JGE cb        Jump short if greater or equal (SF=OF)
  445. 7C cb       JL cb         Jump short if less (SF/=OF)                less=SIGNED
  446. 7E cb       JLE cb        Jump short if less or equal (ZF=1 or SF/=OF)
  447. EB cb       JMP cb        Jump short (signed byte relative to next instruction)
  448. EA cd       JMP cd        Jump far (4-byte immediate address)
  449. E9 cw       JMP cw        Jump near (word offset relative to next instruction)
  450. FF /4       JMP ew        Jump near to EA word (absolute offset)
  451. FF /5       JMP md        Jump far (4-byte address in memory doubleword)
  452. 76 cb       JNA cb        Jump short if not above (CF=1 or ZF=1)
  453. 72 cb       JNAE cb       Jump short if not above or equal (CF=1)
  454. 73 cb       JNB cb        Jump short if not below (CF=0)
  455. 77 cb       JNBE cb       Jump short if not below or equal (CF=0 and ZF=0)
  456. 73 cb       JNC cb        Jump short if not carry (CF=0)
  457. 75 cb       JNE cb        Jump short if not equal (ZF=0)
  458. 7E cb       JNG cb        Jump short if not greater (ZF=1 or SF/=OF)
  459. 7C cb       JNGE cb       Jump short if not greater or equal (SF/=OF)
  460. 7D cb       JNL cb        Jump short if not less (SF=OF)
  461. 7F cb       JNLE cb       Jump short if not less or equal (ZF=0 and SF=OF)
  462. 71 cb       JNO cb        Jump short if not overflow (OF=0)
  463. 7B cb       JNP cb        Jump short if not parity (PF=0)
  464. 79 cb       JNS cb        Jump short if not sign (SF=0)
  465. 75 cb       JNZ cb        Jump short if not zero (ZF=0)
  466. 70 cb       JO cb         Jump short if overflow (OF=1)
  467. 7A cb       JP cb         Jump short if parity (PF=1)
  468. 7A cb       JPE cb        Jump short if parity even (PF=1)
  469. 7B cb       JPO cb        Jump short if parity odd (PF=0)
  470. 78 cb       JS cb         Jump short if sign (SF=1)
  471. 74 cb       JZ cb         Jump short if zero (ZF=1)
  472. 9F          LAHF          Load: AH = flags  SF ZF xx AF xx PF xx CF
  473. 0F 02 /r   *LAR rw,ew     Load: high(rw) = Access Rights byte, selector ew
  474. C5 /r       LDS rw,ed     Load EA doubleword into DS and word register
  475. 8D /r       LEA rw,m      Calculate EA offset given by M, place in rw
  476. C9         *LEAVE         Set SP to BP, then POP BP (reverses previous ENTER)
  477. C4 /r       LES rw,ed     Load EA doubleword into ES and word register
  478. 0F 01 /2   *LGDT m        Load 6 bytes at m into Global Descriptor Table reg
  479. 0F 01 /3   *LIDT m        Load 6 bytes at m into Interrupt Descriptor Table reg
  480. 0F 00 /2   *LLDT ew       Load selector ew into Local Descriptor Table reg
  481. 0F 01 /6   *LMSW ew       Load EA word into Machine Status Word
  482. F0          LOCK (prefix) Assert BUSLOCK signal for the next instruction
  483. 0F 33/r    #LODBITS rb,rb Load AX with DS:SI,bit rb (incr. SI,rb), rb+1 bits
  484. 0F 3B/0 ib #LODBITS rb,ib Load AX with DS:SI,bit rb (incr. SI,rb), ib+1 bits
  485. AC          LODS mb       Load byte [SI] into AL, advance SI
  486. AD          LODS mw       Load byte [SI] into AL, advance SI
  487. AC          LODSB         Load byte [SI] into AL, advance SI
  488. AD          LODSW         Load byte [SI] into AL, advance SI
  489.                                                           6-10
  490.  
  491. E2 cb       LOOP cb       noflags DEC CX; jump short if CX/=0
  492. E1 cb       LOOPE cb      noflags DEC CX; jump short if CX/=0 and equal (ZF=1)
  493. E0 cb       LOOPNE cb     noflags DEC CX; jump short if CX/=0 and not equal
  494. E0 cb       LOOPNZ cb     noflags DEC CX; jump short if CX/=0 and ZF=0
  495. E1 cb       LOOPZ cb      noflags DEC CX; jump short if CX/=0 and zero (ZF=1)
  496. 0F 03 /r   *LSL rw,ew     Load: rw = Segment Limit, selector ew
  497. 0F 00 /3   *LTR ew        Load EA word into Task Register
  498. A0 iw       MOV AL,xb     Move byte variable (offset iw) into AL
  499. A1 iw       MOV AX,xw     Move word variable (offset iw) into AX
  500. 8E /3       MOV DS,mw     Move memory word into DS
  501. 8E /3       MOV DS,rw     Move word register into DS
  502. C6 /0 ib    MOV eb,ib     Move immediate byte into EA byte
  503. 88 /r       MOV eb,rb     Move byte register into EA byte
  504. 8E /0       MOV ES,mw     Move memory word into ES
  505. 8E /0       MOV ES,rw     Move word register into ES
  506. 8C /1       MOV ew,CS     Move CS into EA word
  507. 8C /3       MOV ew,DS     Move DS into EA word
  508. C7 /0 iw    MOV ew,iw     Move immediate word into EA word
  509. 8C /0       MOV ew,ES     Move ES into EA word
  510. 89 /r       MOV ew,rw     Move word register into EA word
  511. 8C /2       MOV ew,SS     Move SS into EA word
  512. B0+rb ib    MOV rb,ib     Move immediate byte into byte register
  513. 8A /r       MOV rb,eb     Move EA byte into byte register
  514. B8+rw iw    MOV rw,iw     Move immediate word into word register
  515. 8B /r       MOV rw,ew     Move EA word into word register
  516. 8E /2       MOV SS,mw     Move memory word into SS
  517. 8E /2       MOV SS,rw     Move word register into SS
  518. A2 iw       MOV xb,AL     Move AL into byte variable (offset iw)
  519. A3 iw       MOV xw,AX     Move AX into word register (offset iw)
  520. A4          MOVS mb,mb    Move byte [SI] to ES:[DI], advance SI and DI
  521. A5          MOVS mw,mw    Move word [SI] to ES:[DI], advance SI and DI
  522. A4          MOVSB         Move byte DS:[SI] to ES:[DI], advance SI and DI
  523. A5          MOVSW         Move word DS:[SI] to ES:[DI], advance SI and DI
  524. F6 /4       MUL eb        Unsigned multiply (AX = AL * EA byte)
  525. F7 /4       MUL ew        Unsigned multiply (DXAX = AX * EA word)
  526. F6 /3       NEG eb        Two's complement negate EA byte
  527. F7 /3       NEG ew        Two's complement negate EA word
  528.             NIL (prefix)  Special "do-nothing" opcode assembles no code
  529. 90          NOP           No Operation
  530. F6 /2       NOT eb        Reverse each bit of EA byte
  531. F7 /2       NOT ew        Reverse each bit of EA word
  532. 0F 16/0    #NOTBIT eb,CL  Complement bit CL of eb
  533. 0F 17/0    #NOTBIT ew,CL  Complement bit CL of ew
  534. 0F 1E/0 ib #NOTBIT eb,ib  Complement bit ib of eb
  535. 0F 1F/0 ib #NOTBIT ew,ib  Complement bit ib of ew
  536. 0C ib       OR AL,ib      Logical-OR immediate byte into AL
  537. 0D iw       OR AX,iw      Logical-OR immediate word into AX
  538. 80 /1 ib    OR eb,ib      Logical-OR immediate byte into EA byte
  539. 08 /r       OR eb,rb      Logical-OR byte register into EA byte
  540. 81 /1 iw    OR ew,iw      Logical-OR immediate word into EA word
  541. 09 /r       OR ew,rw      Logical-OR word register into EA word
  542. 0A /r       OR rb,eb      Logical-OR EA byte into byte register
  543. 0B /r       OR rw,ew      Logical-OR EA word into word register
  544.                                                           6-11
  545.  
  546. E6 ib       OUT ib,AL     Output byte AL to immediate port number ib
  547. E7 ib       OUT ib,AX     Output word AX to immediate port number ib
  548. EE          OUT DX,AL     Output byte AL to port number DX
  549. EF          OUT DX,AX     Output word AX to port number DX
  550. 6E         *OUTS DX,eb    Output byte [SI] to port number DX, advance SI
  551. 6F         *OUTS DX,ew    Output word [SI] to port number DX, advance SI
  552. 6E         *OUTSB         Output byte DS:[SI] to port number DX, advance SI
  553. 6F         *OUTSW         Output word DS:[SI] to port number DX, advance SI
  554. 1F          POP DS        Set DS to top of stack, increment SP by 2
  555. 07          POP ES        Set ES to top of stack, increment SP by 2
  556. 8F /0       POP mw        Set memory word to top of stack, increment SP by 2
  557. 58+rw       POP rw        Set word register to top of stack, increment SP by 2
  558. 17          POP SS        Set SS to top of stack, increment SP by 2
  559. 61         *POPA          Pop DI,SI,BP,SP,BX,DX,CX,AX (SP value is ignored)
  560. 9D          POPF          Set flags register to top of stack, increment SP by 2
  561. 0E          PUSH CS       Set [SP-2] to CS, then decrement SP by 2
  562. 1E          PUSH DS       Set [SP-2] to DS, then decrement SP by 2
  563. 06          PUSH ES       Set [SP-2] to ES, then decrement SP by 2
  564. 6A ib      *PUSH ib       Push sign-extended immediate byte
  565. 68 iw      *PUSH iw       Set [SP-2] to immediate word, then decrement SP by 2
  566. FF /6       PUSH mw       Set [SP-2] to memory word, then decrement SP by 2
  567. 50+rw       PUSH rw       Set [SP-2] to word register, then decrement SP by 2
  568. 16          PUSH SS       Set [SP-2] to SS, then decrement SP by 2
  569. 60         *PUSHA         Push AX,CX,DX,BX,original SP,BP,SI,DI
  570. 9C          PUSHF         Set [SP-2] to flags register, then decrement SP by 2
  571. D0 /2       RCL eb,1      Rotate 9-bit quantity (CF, EA byte) left once
  572. D2 /2       RCL eb,CL     Rotate 9-bit quantity (CF, EA byte) left CL times
  573. C0 /2 ib   *RCL eb,ib     Rotate 9-bit quantity (CF, EA byte) left ib times
  574. D1 /2       RCL ew,1      Rotate 17-bit quantity (CF, EA word) left once
  575. D3 /2       RCL ew,CL     Rotate 17-bit quantity (CF, EA word) left CL times
  576. C1 /2 ib   *RCL ew,ib     Rotate 17-bit quantity (CF, EA word) left ib times
  577. D0 /3       RCR eb,1      Rotate 9-bit quantity (CF, EA byte) right once
  578. D2 /3       RCR eb,CL     Rotate 9-bit quantity (CF, EA byte) right CL times
  579. C0 /3 ib   *RCR eb,ib     Rotate 9-bit quantity (CF, EA byte) right ib times
  580. D1 /3       RCR ew,1      Rotate 17-bit quantity (CF, EA word) right once
  581. D3 /3       RCR ew,CL     Rotate 17-bit quantity (CF, EA word) right CL times
  582. C1 /3 ib   *RCR ew,ib     Rotate 17-bit quantity (CF, EA word) right ib times
  583. F3          REP (prefix)  Repeat following MOVS,LODS,STOS,INS, or OUTS CX times
  584. 65         #REPC (prefix) Repeat following CMPS or SCAS CX times or until CF=0
  585. F3          REPE (prefix) Repeat following CMPS or SCAS CX times or until ZF=0
  586. 64         #REPNC (prefix)Repeat following CMPS or SCAS CX times or until CF=1
  587. F2          REPNE (prefix)Repeat following CMPS or SCAS CX times or until ZF=1
  588. F2          REPNZ (prefix)Repeat following CMPS or SCAS CX times or until ZF=0
  589. F3          REPZ (prefix) Repeat following CMPS or SCAS CX times or until ZF=1
  590. CB          RETF          Return to far caller (pop offset, then seg)
  591. C3          RET           Return to near caller (pop offset only)
  592. CA iw       RETF iw       RET (far), pop offset, seg, iw bytes
  593. C2 iw       RET iw        RET (near), pop offset, iw bytes pushed before Call
  594.                                                           6-12
  595.  
  596. D0 /0       ROL eb,1      Rotate 8-bit EA byte left once
  597. D2 /0       ROL eb,CL     Rotate 8-bit EA byte left CL times
  598. C0 /0 ib   *ROL eb,ib     Rotate 8-bit EA byte left ib times
  599. D1 /0       ROL ew,1      Rotate 16-bit EA word left once
  600. D3 /0       ROL ew,CL     Rotate 16-bit EA word left CL times
  601. C1 /0 ib   *ROL ew,ib     Rotate 16-bit EA word left ib times
  602. 0F 28/0    #ROL4 eb       Rotate nibbles: Heb=Leb   HAL,Leb=LAL  LAL=Heb
  603. D0 /1       ROR eb,1      Rotate 8-bit EA byte right once
  604. D2 /1       ROR eb,CL     Rotate 8-bit EA byte right CL times
  605. C0 /1 ib   *ROR eb,ib     Rotate 8-bit EA byte right ib times
  606. D1 /1       ROR ew,1      Rotate 16-bit EA word right once
  607. D3 /1       ROR ew,CL     Rotate 16-bit EA word right CL times
  608. C1 /1 ib   *ROR ew,ib     Rotate 16-bit EA word right ib times
  609. 0F 2A/0    #ROR4 eb       Rotate nibbles: Leb=Heb   Heb=LAL  AL=eb
  610. 9E          SAHF          Store AH into flags  SF ZF xx AF xx PF xx CF
  611. D0 /4       SAL eb,1      Multiply EA byte by 2, once
  612. D2 /4       SAL eb,CL     Multiply EA byte by 2, CL times
  613. C0 /4 ib   *SAL eb,ib     Multiply EA byte by 2, ib times
  614. D1 /4       SAL ew,1      Multiply EA word by 2, once
  615. D3 /4       SAL ew,CL     Multiply EA word by 2, CL times
  616. C1 /4 ib   *SAL ew,ib     Multiply EA word by 2, ib times
  617. D0 /7       SAR eb,1      Signed divide EA byte by 2, once
  618. D2 /7       SAR eb,CL     Signed divide EA byte by 2, CL times
  619. C0 /7 ib   *SAR eb,ib     Signed divide EA byte by 2, ib times
  620. D1 /7       SAR ew,1      Signed divide EA word by 2, once
  621. D3 /7       SAR ew,CL     Signed divide EA word by 2, CL times
  622. C1 /7 ib   *SAR ew,ib     Signed divide EA word by 2, ib times
  623. 1C ib       SBB AL,ib     Subtract with borrow immediate byte from AL
  624. 1D iw       SBB AX,iw     Subtract with borrow immediate word from AX
  625. 80 /3 ib    SBB eb,ib     Subtract with borrow immediate byte from EA byte
  626. 18 /r       SBB eb,rb     Subtract with borrow byte register from EA byte
  627. 83 /3 ib    SBB ew,ib     Subtract with borrow immediate byte from EA word
  628. 81 /3 iw    SBB ew,iw     Subtract with borrow immediate word from EA word
  629. 19 /r       SBB ew,rw     Subtract with borrow word register from EA word
  630. 1A /r       SBB rb,eb     Subtract with borrow EA byte from byte register
  631. 1B /r       SBB rw,ew     Subtract with borrow EA word from word register
  632. AE          SCAS mb       Compare bytes AL - ES:[DI], advance DI
  633. AF          SCAS mw       Compare words AL - ES:[DI], advance DI
  634. AE          SCASB         Compare bytes AX - ES:[DI], advance DI
  635. AF          SCASW         Compare words AX - ES:[DI], advance DI
  636. 0F 14/0    #SETBIT eb,CL  Set bit CL of eb
  637. 0F 15/0    #SETBIT ew,CL  Set bit CL of ew
  638. 0F 1C/0 ib #SETBIT eb,ib  Set bit ib of eb
  639. 0F 1D/0 ib #SETBIT ew,ib  Set bit ib of ew
  640. 0F 01 /0   *SGDT m        Store 6-byte Global Descriptor Table register to M
  641. D0 /4       SHL eb,1      Multiply EA byte by 2, once
  642. D2 /4       SHL eb,CL     Multiply EA byte by 2, CL times
  643. C0 /4 ib   *SHL eb,ib     Multiply EA byte by 2, ib times
  644. D1 /4       SHL ew,1      Multiply EA word by 2, once
  645. D3 /4       SHL ew,CL     Multiply EA word by 2, CL times
  646. C1 /4 ib   *SHL ew,ib     Multiply EA word by 2, ib times
  647.                                                           6-13
  648.  
  649. D0 /5       SHR eb,1      Unsigned divide EA byte by 2, once
  650. D2 /5       SHR eb,CL     Unsigned divide EA byte by 2, CL times
  651. C0 /5 ib   *SHR eb,ib     Unsigned divide EA byte by 2, ib times
  652. D1 /5       SHR ew,1      Unsigned divide EA word by 2, once
  653. D3 /5       SHR ew,CL     Unsigned divide EA word by 2, CL times
  654. C1 /5 ib   *SHR ew,ib     Unsigned divide EA word by 2, ib times
  655. 0F 01 /1   *SIDT m        Store 6-byte Interrupt Descriptor Table register to M
  656. 0F 00 /0   *SLDT ew       Store Local Descriptor Table register to EA word
  657. 0F 01 /4   *SMSW ew       Store Machine Status Word to EA word
  658. F9          STC           Set carry flag
  659. FD          STD           Set direction flag so SI and DI will decrement
  660. FB          STI           Set interrupt enable flag, interrupts enabled
  661. 0F 31/r    #STOBITS rb,rb Store AX to ES:DI,bit rb (incr. DI,rb), rb+1 bits
  662. 0F 39/0 ib #STOBITS rb,ib Store AX to ES:DI,bit rb (incr. DI,rb), ib+1 bits
  663. AA          STOS mb       Store AL to byte [DI], advance DI
  664. AB          STOS mw       Store AX to word [DI], advance DI
  665. AA          STOSB         Store AL to byte ES:[DI], advance DI
  666. AB          STOSW         Store AX to word ES:[DI], advance DI
  667. 0F 00 /1   *STR ew        Store Task Register to EA word
  668. 2C ib       SUB AL,ib     Subtract immediate byte from AL
  669. 2D iw       SUB AX,iw     Subtract immediate word from AX
  670. 80 /5 ib    SUB eb,ib     Subtract immediate byte from EA byte
  671. 28 /r       SUB eb,rb     Subtract byte register from EA byte
  672. 83 /5 ib    SUB ew,ib     Subtract immediate byte from EA word
  673. 81 /5 iw    SUB ew,iw     Subtract immediate word from EA word
  674. 29 /r       SUB ew,rw     Subtract word register from EA word
  675. 2A /r       SUB rb,eb     Subtract EA byte from byte register
  676. 2B /r       SUB rw,ew     Subtract EA word from word register
  677. 0F 22      #SUB4S         Sub CL nibbles BCD at DS:SI from ES:DI (CL even,NZ)
  678. A8 ib       TEST AL,ib    AND immediate byte into AL for flags only
  679. A9 iw       TEST AX,iw    AND immediate word into AX for flags only
  680. F6 /0 ib    TEST eb,ib    AND immediate byte into EA byte for flags only
  681. 84 /r       TEST eb,rb    AND byte register into EA byte for flags only
  682. F7 /0 iw    TEST ew,iw    AND immediate word into EA word for flags only
  683. 85 /r       TEST ew,rw    AND word register into EA word for flags only
  684. 84 /r       TEST rb,eb    AND EA byte into byte register for flags only
  685. 85 /r       TEST rw,ew    AND EA word into word register for flags only
  686. 0F 10/0    #TESTBIT eb,CL Test bit CL of eb, set Z flag
  687. 0F 11/0    #TESTBIT ew,CL Test bit CL of ew, set Z flag
  688. 0F 18/0 ib #TESTBIT eb,ib Test bit ib of eb, set Z flag
  689. 0F 19/0 ib #TESTBIT ew,ib Test bit ib of ew, set Z flag
  690. 9B          WAIT          Wait until BUSY pin is inactive (HIGH)
  691. 0F 00 /4   *VERR ew       Set ZF=1 if segment can be read, selector ew
  692. 0F 00 /5   *VERW ew       Set ZF=1 if segment can be written to, selector ew
  693.                                                           6-14
  694.  
  695. 9r          XCHG AX,rw    Exchange word register with AX
  696. 86 /r       XCHG eb,rb    Exchange byte register with EA byte
  697. 87 /r       XCHG ew,rw    Exchange word register with EA word
  698. 86 /r       XCHG rb,eb    Exchange EA byte with byte register
  699. 9r          XCHG rw,AX    Exchange  with word register
  700. 87 /r       XCHG rw,ew    Exchange EA word with word register
  701. D7          XLAT mb       Set AL to memory byte [BX + unsigned AL]
  702. D7          XLATB         Set AL to memory byte DS:[BX + unsigned AL]
  703. 34 ib       XOR AL,ib     Exclusive-OR immediate byte into AL
  704. 35 iw       XOR AX,iw     Exclusive-OR immediate word into AX
  705. 80 /6 ib    XOR eb,ib     Exclusive-OR immediate byte into EA byte
  706. 30 /r       XOR eb,rb     Exclusive-OR byte register into EA byte
  707. 81 /6 iw    XOR ew,iw     Exclusive-OR immediate word into EA word
  708. 31 /r       XOR ew,rw     Exclusive-OR word register into EA word
  709. 32 /r       XOR rb,eb     Exclusive-OR EA byte into byte register
  710. 33 /r       XOR rw,ew     Exclusive-OR EA word into word register
  711.  
  712. * Starred forms will not execute on 8086/8088!  See note at top of chart.
  713. # These instructions work only on NEC chips!  See note at top of chart.
  714.  
  715.